package com.shop.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.mysql.jdbc.exceptions.MySQLIntegrityConstraintViolationException;
import com.shop.mapper.Pms_Category_Mapper;
import com.shop.pojo.pms.Pms_Category;
import com.shop.service.Pms_Category_Service;
import com.shop.utils.R;
import com.shop.utils.RedisUtil;
import com.shop.vo.CatalogByTree;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
@Service
public class Pms_Category_ServiceImpl implements Pms_Category_Service {
    @Autowired
    private Pms_Category_Mapper pms_category_mapper;
    @Autowired
    private RedisUtil redisUtil;
    /*
     * @Description
     * 1、获取全部分类
     * 2、创建一个存储tree类的集合
     * 3、进行循环遍历，进行判断，
     * 4、如果当前遍历的类的父id是0，那么就说明他是有子类的，
     * 那么就执行下面递归查找子类的方法，然后将当前的类和全部集合传进去即可
     * @param
     * @return java.util.List<com.shop.vo.CatalogByTree>
     * @author liusupeng
     * @date 2020/10/27 13:17
     */
    @Override
    public List<CatalogByTree> getTree() {
        List<CatalogByTree> catalogByTreeList=new ArrayList<>();//创建一个存储的集合
        List<CatalogByTree> tree=new ArrayList<>();
            tree = pms_category_mapper.getTree();//全部的分类
           for(CatalogByTree c:tree){
            if(c.getParent_cid()==0){
                catalogByTreeList.add(findChildren(c,tree));
            }
            System.out.println("层级："+c.getCat_level()+"分类id"+c.getId());
        }
        return catalogByTreeList;
    }

    //调用下面的方法
    @Override
    public List<CatalogByTree> getHomeTree() {
        boolean catalogByHomeTree = redisUtil.hasKey("catalogByHomeTree");
        if(catalogByHomeTree){
            return (List<CatalogByTree>) redisUtil.get("catalogByHomeTree");
        }else{
            List<CatalogByTree> homeTreeToDb = getHomeTreeToDb();
            redisUtil.set("catalogByHomeTree", homeTreeToDb);
            boolean catalogByHomeTree1 = redisUtil.expire("catalogByHomeTree", 600);
            System.out.println(catalogByHomeTree1);
            return homeTreeToDb;
        }


    }

    /*
     * @Description
     * 1、获取全部分类并且包含分类所属品牌
     * 2、创建一个存储tree类的集合
     * 3、进行循环遍历，进行判断，
     * 4、如果当前遍历的类的父id是0，那么就说明他是有子类的，
     * 那么就执行下面递归查找子类的方法，然后将当前的类和全部集合传进去即可
     * @param
     * @return java.util.List<com.shop.vo.CatalogByTree>
     * @author liusupeng
     * @date 2020/11/13 13:17
     */
    public List<CatalogByTree> getHomeTreeToDb() {
        List<CatalogByTree> catalogByTreeList=new ArrayList<>();//创建一个存储的集合
        List<CatalogByTree> tree=new ArrayList<>();
        tree = pms_category_mapper.getHomeTree();//全部的分类
        for(CatalogByTree c:tree){
            if(c.getParent_cid()==0){
                catalogByTreeList.add(findChildren(c,tree));
            }
        }
        return catalogByTreeList;
    }

    /*
     * @Description 为商品分类添加一条信息
     * 如果成功则返回code=200，msg=success
     * 如果失败则返回code=500，msg=数据库异常
     * 如果数据库导致异常，就是因为名称重复，通过异常来处理了
     * @param category
     * @return com.shop.utils.R
     * @author liusupeng
     * @date 2020/10/29 8:52
     */
    @Override
    public R addCatalog(Pms_Category category) {

        try {
            int insert = pms_category_mapper.insert(category);
            if(insert>0){
                redisUtil.del("tree");//删除缓存
                return R.success();
            }
        }catch (Exception e){
            return R.error(500,"名称已经存在");
        }


        return R.error(500,"服务器异常");

    }
    /*
     * @Description 为商品分类修改一条信息，根据主键ID来进行修改
     * 如果成功则返回code=200，msg=success
     * 如果失败则返回code=500，msg=数据库异常
     * 如果数据库导致异常，就是因为名称重复，通过异常来处理了
     * @param category
     * @return com.shop.utils.R
     * @author liusupeng
     * @date 2020/10/29 8:52
     */
    @Override
    public R updateCatalog(Pms_Category category) {



        try {
            int update = pms_category_mapper.updateById(category);
            if(update>0){
                redisUtil.del("tree");//删除缓存
                return R.success();
            }
        }catch (Exception e){
            return R.error(500,"名称已经存在");
        }

        return R.error(500,"服务器异常");
    }
    /*
     * @Description 根据ID删除商品分类
     * 1、首先根据这个id查询有没有分类的父id和他对应
     * 如果有的话则代表该分类是有子分类的，不可删除
     * 如果没有的话则代表可以删除
     * @param catelogId
     * @return com.shop.utils.R
     * @author liusupeng
     * @date 2020/10/29 11:39
     */
    @Override
    public R delCatalog(Integer catelogId) {


        QueryWrapper<Pms_Category> queryWrapper=new QueryWrapper<>();
        queryWrapper.eq("parent_cid",catelogId);
        List<Pms_Category> pms_categories = pms_category_mapper.selectList(queryWrapper);
        if(pms_categories.size()==0){
            pms_category_mapper.deleteById(catelogId);
            redisUtil.del("tree");//删除缓存
            return R.success();
        }

        return R.error(500,"当前分类下有数据不可删除");
    }

    @Override
    public R getCategoryByThree() {
        QueryWrapper<Pms_Category> queryWrapper=new QueryWrapper<>();
        queryWrapper.eq("cat_level",3);
        List<Pms_Category> pms_categories = pms_category_mapper.selectList(queryWrapper);
        R r1=new R();
        r1.data(pms_categories);
        return r1;
    }

    /*
     * @Description
     * 1、首先遍历全部分类
     * 2、创建一个对象在循环里接收这个分类，
     * 3、用这个对象和方法传来的分类对象进行比较，如果传来的id和我们当前遍历的对象的父id相等，那就代表他是老大
     * 4、接着判断他目前有子类没有，如果没有的话我们给他创建一个children集合
     * 5、然后在这个children里面添加我们当前这个方法，让他一直进行循环。直到传来的对象的id和我们的父id不相等，就代表没有子类了
     * @param c  传来的带有真实数据的单个分类
     * @param catalogByTrees 带有真实数据的集合分类（全部分类）
     * @return com.shop.vo.CatalogByTree
     * @author liusupeng
     * @date 2020/10/27 13:13
     */
    public CatalogByTree findChildren(CatalogByTree c, List<CatalogByTree> catalogByTrees) {

        for(CatalogByTree item:catalogByTrees){
            if(c.getId()==item.getParent_cid()){
                if(c.getChildren()==null){
                    c.setChildren(new ArrayList<CatalogByTree>());
                }
                c.getChildren().add(findChildren(item,catalogByTrees));
            }
        }
        return c;
    }
}
